Práctica 06: Perceptron de una capa
Integrantes:
- Palma Mejía Luis Adrián
- Fabián Carrasco Yahadad
- Flores Vázquez Elvin
- Tenorio Camacho Javier
Objetivos
- Implementar la regla de aprendizaje perceptrón par entradas en

- Implementar visulización en
y 
Introducción
El articulo aborda la manera en la que el modelo del preceptron es un modelo que se asemeja a o podria plantearse como una alternativa al entendimiento de como el cerebro procesa la información.
Se comienza plantenando tres preguntas fundamentales que como seres humanos realizamos dia a dia aun que raramente nos detenemos a reflexionar el como suceden, y es relacionado a la manera en la que procesamos la información, partiendo de ¿como son detectados los estimulos que nos proven cierta información?, ¿Como es esta información almacenda? y por ultimo, ¿como esta información influye en nuestr comportameinto o en la manera en la que reconocemos las cosas?.
Principalmente centrandose en las ultimas dos preguntas, y partiendo por la primera de estas dos. Se plantea que el cerebro almacena información en forma de codigos o imagenes en un modo de clasificación de el estimulo recibido con un patronalmacenado o aprendido. Por otro lado tambien se plantea que en realidad el cerebro no realiza un almacenamiento como tal, sino que en el sistema nervioso central (SNC), se crean nuevas rutas hacia ciertas zonas del cerebro con lo que los estimulos entrantesseria mas equiparados a una idea que una acción concreta. De otro modo se puede decir que la primer idea cataloga un estimulo con cierto patron , y la segunda asocia ciertas caracteristicas de dicho estimulo creando una asociaciones de elementos de dicho estumulo sin catalogarlo perse.
Teniendo en cuenta estas dos hipotessis de "almacenamiento" de la información la respuesta a la tecer pregunta, para la primera hipotesis se basa en que al compararse de manera sistematica los estimulos entrantes con los ya clasificados, de la misma manera se determina el comportamiento a los estimulos dentro de las mimmas "clases" de almacenamiento mientras que de acuerdo a la segunda hipotesis, los estimulos entrantes seguiran los mismos caminos (o al menos caminos parecidos) a los que correspondientes a estimulos anteriores a estos.
Esta ultima teoria llamada "Coneccionista" seria la manera enla que el perceptron toma decisiones.
De esta manera conociendo la manera en la que trabaja el perceptron podriamos decir que cada vez que se entra una red de esta arquitectura y los pesos y desviaciones se ajustan, seria similar a la manera en la que un estimulo seguiria un mismo camino o uno parecido al de un estimilo similar que entro anteriormente mientras que estos mismos cominos serian los formados con cada entrenamiento, por lo que despues de muchas decadas de entrenamiento los estimulos asociados a ciertos patrones tendrian aociada de manera practicamente inmediata la respuesta a la que estan asociados estos tipos de estimulos.
Otro punto importante tambien a tomar en cuenta es que no todos los SNC son iguales por lo que su ruta de aprendizaje es distinta, esto en similitud en la manera en la que se incia elaprendizaje de un perceptron indicaria la manera en la que como todos estos sstemas apprende en algunas ocaciones mas o menos rapido.
Problemas
Problema 1
Elabore una función que entrene un perceptron de 1 capa y S neuronas. Para ello considere lo siguiente:
- La función recibe de argumentos el conjunto de entradas P de dimensión R, y los objetivos correspondientes t de dimención n.
- La función recibe el numero de epocas de entrenamiento
- La función recibe como parametro opcional una tolerancia (numero real positivo, que se piensa pequeño) como un criterio de paro adicional.
- La función regresa los pesos y la desviación resultante, con un mensaje de exito o fracaso, indicando bajo que circunstancias se reportan los resultados.
El numeró de neuronas debe de elegirse de acuerdo a la dimensión t (¿por qué?)
Porque la cantidad de clases máximas que una arquitectura puede clasifica depende del número de neuronas, más específicamente
será el número máximo de clases que un perceptrón de S neuronas puede clasificar
Puede iniciaizar los parámetros con numeros aleatorios pequeños incluso pueden ser cero.
El programa debe deternerse de acuerdo a diferentes criterios:
- Se logro el entrenamiento antes del numero de epocas indicado, se indica que esto ocurre
- Se alcanzo el número de epocas ingresado, se debe indicar si con esta selección se logro o no el entrenamiento
- Se logro la tolerancia indicada (en caso de ser ingresada). Es decir, si
donde la resta es entre los parametros estimados en la epoca i e
, con la norma usual (aunque algunos algortimos utilizan la norma infinito, puedes implementar esta en lugar de la norma 2, si así lo deseas). Se despliega un menaje para indicar que esto ocurrio function [W,b] = perceptron1(entradas,objetivos,epocas,tolerancia)
if nargin<4
tolerancia = 1;
end
[r,numr] = size(entradas);
[n,numt] = size(objetivos);
% numero de clases
numClase = zeros(1,numt);
for tt=1:numt
cont = 0;
for exp=1:n
cont = (2^(exp-1))*objetivos(exp,tt) + cont;
end
numClase(tt) = cont;
end
numClases = length(unique(numClase));
% neuronas = ceil(log2(numClases));
syms n
eq = 1 + (n+1)*n/2 == numClases;
res = double(solve(eq,n));
sol = find(res >= 0);
neuronas = ceil(res(sol(1)));
disp('Existen '+string(numClases) +' clases, por lo que se necesitan '+ string(neuronas) + ' neuronas')
% fin numero de clases
% disp(neuronas)
% Generar los pesos y desviaciones
rng(0,'twister');
W = round((100-(-100)).*rand(r,neuronas) + (-100));
b = round((100-(-100)).*rand(neuronas,1) + (-100));
% size(W): columnas pesos(entradas), filas son neuronas
% W = numr x neuronas
% W = [0; 0];
% b = [0];
% W = [1 0;0 1];
% b = [1;1];
flag1 = true;
r = neuronas;
while epocas > 0 && flag1
W0 = W(:,end-r+1:end)';
% disp(W0)
b0 = b(:,end);
% disp(b0)
for it=1:numt
p = entradas(:,it);
% disp('p')
% disp(p)
t = objetivos(:,it);
% disp('t')
% disp(t)
a = hardlim(W0 * p + b0);
% disp('a')
% disp(a)
e = t - a;
% disp('e')
% disp(e)
W = horzcat(W,(W0 + e * p')');
b = horzcat(b,b0 + e);
W0 = W(:,end-r+1:end)';
b0 = b(:,end);
end
if sum((W(:,end-r+1:end) - W(:,end - numt*r+1:end - numt*r + r)).^2) < tolerancia % Norma 2
% if sum((W(:,end) - W(:,end - numt)).^2) < tolerancia % Norma 2
% if sum((abs(W(:,end)) - W(:,end - numt)).^2) < tolerancia % Norma Infinito
flag1 = false;
end
epocas = epocas - 1;
end
W0 = W(:,end)';
% disp('W0')
% disp(W0)
b0 = b(:,end);
% disp('b0')
% disp(b0)
tfinal = hardlim(W(:,end-r+1:end)'*entradas + b(:,end));
% disp('tfinal')
% disp(tfinal)
if epocas == 0
disp('Se alcanzo el numero de epocas')
else
disp('No se alcanzo el numero de epocas')
end
if all(tfinal == objetivos)
disp('La clasificacion es correcta')
else
disp('La clasificacion no es correcta')
end
if flag1 == true
disp('No se cumple la tolerancia de '+string(tolerancia))
else
disp('Se cumple la tolerancia de '+string(tolerancia))
end
% plot(C1(1,:),C1(2,:), 'bo', 'MarkerSize',20)
%
% plot(C2(1,:),C2(2,:), 'gs','MarkerSize',20)
% plot(C3(1,:),C3(2,:), 'ro', 'MarkerSize',30, 'LineWidth',5)
% plot(C4(1,:),C4(2,:), 'ks','MarkerSize',30,'LineWidth',5)
end
Problema 2
Elabore una función para clasificar vectores en
con las siguientes características - La función recibe el numero de clases, las entradas y objetivos correspondientes
- El entrenamiento se lleva acabo mediante la regla de perceptrón (la suposición es que el problema es linealmente separable, por lo que el algoritmo tendrá que terminar de entrenarse), aquí puedes utilizar la función del problema 1, si asi lo deseas.
- La función despliega una gráfica donde se muestren elementos gráficos para indicar los vectores asociados a cada clase, los hiperplanos correspondientes de separación. los vectores ortogonales a cada plano y etiquetas de descripción (ejemplos clase)
- La función imprime los parametrós calculados, el número de epocas de entreanmiento con lo qeu esto se logro y las ecuaciones de los hiperplanos separadores.
- La función imprime en una misma figura el movimiento de los pesos en cada iteración de forma independiente. Por ejemplo, si se tienen 2 neuronas la figura tendrá que mostrar 4 graficas (la sucesión de cada peso, esto ilustra la convergencia). Para el bias se tendrá que contruir una segunda figura que muestre las sucesión de las desviaciones, en el ejemplo de dos neuronas, la figura tendría que tener la gráfica de dos sucesiones.
Proponga un problema de clasificación con 8 clases, que sea linealmente separable, donde cada clase tenga dos vectores asociados para el entrenamiento.
Para este problema se usan los siguientes puntos y objetivos, donde la función problema2 hace uso de la función perceptron1 con la diferencia que usa los datos de retorno para realizar las gráficas t = [t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16];
p = [p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15,p16];
problema2(p,t,100);
Existen 8 clases, por lo que se necesitan 4 neuronas
Se alcanzo el numero de epocas
La clasificacion no es correcta
No se cumple la tolerancia de 1
neuronas
4
El video donde se observa el funcionamiento del código implementado se puede descargar en el siguiente enlace o ver en el siguiente enlace. Problema 3
Resuelva el problema 2 para clasificar vectores en
. En el cápitulo 3 de Hagan hay un ejemplo de aplicación, páginas 3-1 a 3-6. Con esta idea, aplica la solución de ente probelma para clasificar naranjas y manzanas. Considera que los vectores de manzanas, están en el I octante, y los de naranjas en el III octante. Propon 2 entradas para cada clase.
Se entrega el resultado, y el enlace a un video (o se inserta el video) para ver la aplicación.
La GUI del problema de naranjas y manzanas
Problema 4
Se muestran los siguiente códigos en MATLAB
Clasificación, dos clases en
Creamos datos de entrenamiento de forma artificial
close all, clear all, clc, format compact
% numero de puntos para cada clase
% definición aritficial de entradas y salidas
offset = 5; % separación para las clases
x = [randn(2,N) randn(2,N)+offset]; % entradas
y = [zeros(1,N) ones(1,N)]; % salidas
% Gráfica de entradas con PLOTPV (gráfica vectores para perceptron entradas/salidas)
Definición de la red y entrenamiento
net = perceptron(); % perceptron vacio
view(net) % esquema de topologia de red, tipo Hagan
net.trainParam.showWindow = 0; % no muestra el cuadro de dialogo del entrenamiento
net_trained = train(net,x,y); % entreanmos la red y guardamos la red entrenada
view(net_trained) % esquema de topologia de red entrenada, tipo Hagan
Gráfica de frontera de desición
plotpc(net_trained.IW{1},net_trained.b{1}); % función para impeme
Clasificación, cuatro clases en
close all, clear all, clc, format compact
% numero de muestras en cada clase
% definición de las clases
q = .6; % separación de la clases
A = [rand(1,K)-q; rand(1,K)+q];
B = [rand(1,K)+q; rand(1,K)+q];
C = [rand(1,K)+q; rand(1,K)-q];
D = [rand(1,K)-q; rand(1,K)-q];
figure(1); % no queremos repetir este codigo
figure(2); % creamso dos figura para copiar en contenido
figure(1) % activamos la figura 1
plot(A(1,:),A(2,:),'bs');
text(.5-q,.5+2*q,'Clase A')
text(.5+q,.5+2*q,'Clase B')
text(.5+q,.5-2*q,'Clase C')
text(.5-q,.5-2*q,'Clase D')
% se definenen las salidas para las clases
% % ¿por qué estas salidas no funcionan?
% % ¿por qué estas salidas no funcionan?
CloneFig(1,2) % copiamos la figura 1 a la figura 2
Entradas y salidas
% definen las entradas (combinación para las cuatro clases)
T = [repmat(a,1,length(A)) repmat(b,1,length(B)) ...
repmat(c,1,length(C)) repmat(d,1,length(D)) ];
% aquí sería bueno imprimir P y T para menos estradas, para apreciar como
% se deben concatenar los valores
Se crea el perceptron y se entrena
net.trainParam.showWindow = 0;
net_trained = train(net,P,T);
Gráficamos la frontera de desición
figure(1) % activamos la figura 1
plotpc(net_trained.IW{1},net_trained.b{1});
Se resuleve nuevamente el problema epoca por epoca
figure(2) % activamoos la figira dos que tiene solo la gráfica de los datos
net.adaptParam.passes = 1; % epocas de adaptación
ax2 = plotpc(net.IW{1},net.b{1});
[net,Y,E] = adapt(net,P,T); % regresla la red entrenada, el valor de las salidas, los errores
ax2 = plotpc(net.IW{1},net.b{1},ax2);
drawnow; % efecto de simulación
Se entrega el desarrollo del ejemplo del problema 2 y el desarroolo del ejemplo de de problema 3 con las herramientas antes descritas.
Referencias
F. Rosenblatt, “The perceptron: A probabilistic model for information storage and organization in the brain,” Psycho- logical Review, Vol. 65, pp. 386–408, 1958.
Libro de Matin Hagan et. al. enlace Implemenatción de perceptron con MATLAB, enlace Función para clonar figuras enlace
Funciones utilizadas
function CloneFig(inFigNum,OutFigNum)
% this program copies a figure to another figure
% example: CloneFig(1,4) would copy Fig. 1 to Fig. 4
% pretty much taken from Matlab Technical solutions:
% http://www.mathworks.com/support/solutions/en/data/1-1UTBOL/?solution=1-1UTBOL
function compCopy(op, np)
%COMPCOPY copies a figure object represented by "op" and its % descendants to another figure "np" preserving the same hierarchy.
ch = get(op, 'children');
function [W,b] = perceptron1(entradas,objetivos,epocas,tolerancia)
[r,numr] = size(entradas);
[n,numt] = size(objetivos);
numClase = zeros(1,numt);
cont = (2^(exp-1))*objetivos(exp,tt) + cont;
numClases = length(unique(numClase));
% neuronas = ceil(log2(numClases));
eq = 1 + (n+1)*n/2 == numClases;
res = double(solve(eq,n));
neuronas = ceil(res(sol(1)));
disp('Existen '+string(numClases) +' clases, por lo que se necesitan '+ string(neuronas) + ' neuronas')
% Generar los pesos y desviaciones
W = round((100-(-100)).*rand(r,neuronas) + (-100));
b = round((100-(-100)).*rand(neuronas,1) + (-100));
% size(W): columnas pesos(entradas), filas son neuronas
while epocas > 0 && flag1
a = hardlim(W0 * p + b0);
W = horzcat(W,(W0 + e * p')');
if sum((W(:,end-r+1:end) - W(:,end - numt*r+1:end - numt*r + r)).^2) < tolerancia % Norma 2
% if sum((W(:,end) - W(:,end - numt)).^2) < tolerancia % Norma 2
% if sum((abs(W(:,end)) - W(:,end - numt)).^2) < tolerancia % Norma Infinito
tfinal = hardlim(W(:,end-r+1:end)'*entradas + b(:,end));
disp('Se alcanzo el numero de epocas')
disp('No se alcanzo el numero de epocas')
if all(tfinal == objetivos)
disp('La clasificacion es correcta')
disp('La clasificacion no es correcta')
disp('No se cumple la tolerancia de '+string(tolerancia))
disp('Se cumple la tolerancia de '+string(tolerancia))
% plot(C1(1,:),C1(2,:), 'bo', 'MarkerSize',20)
% plot(C2(1,:),C2(2,:), 'gs','MarkerSize',20)
% plot(C3(1,:),C3(2,:), 'ro', 'MarkerSize',30, 'LineWidth',5)
% plot(C4(1,:),C4(2,:), 'ks','MarkerSize',30,'LineWidth',5)
function [] = problema2(p,t,epocas,tolerancia)
[W,b] = perceptron1(p,t,epocas,tolerancia);
numClase = zeros(1,numt);
cont = (2^(exp-1))*t(exp,tt) + cont;
marcadores = 'o+*.x_|sd^v<>ph'; %15 'o*.s';
numClases = length(unique(numClase));
unicos = unique(numClase);
% neuronas = ceil(log2(numClases));
eq = 1 + (n+1)*n/2 == numClases;
res = double(solve(eq,n));
neuronas = ceil(res(sol(1)));
index = find(numClase == unicos(i));
% disp('Clase '+string(i))
% disp('longitud de '+string(length(index)))
plot(p(1,index),p(2,index), string(marcadores(mod(i-1,15)+1)) + 'k', 'MarkerSize',10,'DisplayName','C'+string(i))
% disp(marcadores(mod(i-1,15)+1))
% plot(p(1,index(j)),p(2,index(j)), string(marcadores(mod(i-1,15)+1)) + 'k', 'MarkerSize',20)
legend('FontSize',5,'Location','bestoutside','NumColumns',1)
% legend("C1","C2","C3","C4",'FontSize',5,'Location','southwest')
g.XAxisLocation = 'origin';
g.YAxisLocation = 'origin';
eq = wlocal * [p1l;p2l] + b1 == 0;
fimplicit(@(p1l,p2l) wlocal(1,1)*p1l + wlocal(1,2)*p2l + b1,[-100,100],colores(mod(i,4)+1))
quiver(p1l,p2l,wlocal(1,1),wlocal(1,2),0, 'MaxHeadSize',0.5,"Color",colores(mod(i,4)+1),'DisplayName','_'+ string(i)+'w')
legend('FontSize',5,'Location','bestoutside','NumColumns',1)
plot(W(1,i:r:end),'o', 'MarkerSize',10)
title('convergencia del peso '+string(j)+ ' de la neurona '+ string(i) )
% axis([0 length(W(1,i:r:end)) min(W(1,i:r:end)) max(W(1,i:r:end))])
g.XAxisLocation = 'origin';
g.YAxisLocation = 'origin';
% [f,c]=size(W(1,i:r:end));
% text(W(1,i:r:end)+0.06*([0:c-1]),W(1,i:r:end)+0.1,string([0:c-1]))
plot(b(1,:),'o', 'MarkerSize',10)
title('convergencia del bias '+string(i))
% axis([0 length(W(1,i:r:end)) min(W(1,i:r:end)) max(W(1,i:r:end))])
g.XAxisLocation = 'origin';
g.YAxisLocation = 'origin';
% [f,c]=size(W(1,i:r:end));
% text(W(1,i:r:end)+0.06*([0:c-1]),W(1,i:r:end)+0.1,string([0:c-1]))